class Vector {
  // 构造函数，初始化一个空数组
  constructor(private list: number[] = []) {}

  /**
   * 获取向量的维度
   */
  get dimension() {
    return this.list.length;
  }

  get length() {
    return this.dimension;
  }

  /**
   * 获取指定索引的元素
   * @param index 索引
   * @returns
   */
  getItem(index: number) {
    return this.list[index];
  }

  /**
   * 将向量转换为字符串
   * @returns 返回一个字符串，表示向量的元素
   */
  toString() {
    let str = "";
    for (let i = 0; i < this.list.length; i++) {
      if (i != this.list.length - 1) {
        str += this.list[i] + ",";
      } else {
        str += this.list[i];
      }
    }
    return `Vector(${str})`;
  }

  /**
   * 向量相加
   * @param another 另一个向量
   * @returns
   */
  add(another: Vector) {
    // 如果两个向量的维度不同，抛出错误
    if (this.dimension != another.dimension) {
      throw new Error("The dimensions of the vectors must be the same");
    }
    const finalList: number[] = [];
    // 遍历两个向量，将对应位置的元素相加
    for (let i = 0; i < this.dimension; i++) {
      finalList.push(this.getItem(i) + another.getItem(i));
    }
    // 返回一个新的向量
    return new Vector(finalList);
  }

  /**
   * 向量相减
   * @param another 另一个向量
   * @returns
   */
  sub(another: Vector) {
    // 如果两个向量的维度不同，抛出错误
    if (this.dimension != another.dimension) {
      throw new Error("The dimensions of the vectors must be the same");
    }
    const finalList: number[] = [];
    // 遍历两个向量，将对应位置的元素相减
    for (let i = 0; i < this.dimension; i++) {
      finalList.push(this.getItem(i) - another.getItem(i));
    }
    // 返回一个新的向量
    return new Vector(finalList);
  }

  /**
   * 向量与一个数相乘
   * @param k 乘数
   * @returns
   */
  // 向量与一个数相乘
  mul(k: number) {
    const finalList: number[] = [];
    // 遍历向量，将每个元素与数相乘
    for (let i = 0; i < this.dimension; i++) {
      finalList.push(this.getItem(i) * k);
    }
    // 返回一个新的向量
    return new Vector(finalList);
  }

  /**
   * 向量与一个数相除
   * @param k 除数
   * @returns
   */
  div(k: number) {
    if (k === 0) {
      throw new Error("Cannot divide by zero");
    }
    // 向量与一个数的倒数相乘
    return this.mul(1 / k);
  }

  /**
   * 向量取正，即将向量中分量变成正数
   * @returns
   */
  pos() {
    // 向量与1相乘
    return this.mul(1);
  }

  /**
   * 向量取负，即将向量中分量变成负数
   * @returns
   */
  neg() {
    // 向量与-1相乘
    return this.mul(-1);
  }

  /**
   * 向量的点积
   * @param another 另一个向量
   * @returns
   */
  dotMul(another: Vector) {
    // 如果两个向量的维度不同，抛出错误
    if (this.dimension != another.dimension) {
      throw new Error("The dimensions of the vectors must be the same");
    }
    let final = 0;
    // 遍历两个向量，将对应位置的元素相乘并累加
    for (let i = 0; i < this.dimension; i++) {
      final += this.getItem(i) * another.getItem(i);
    }
    // 返回结果
    return final;
  }
}

export default Vector;
